// sgu309
// 题意：
// 给定n(<=20000)个平面坐标点，坐标范围[-10^9, 10^9]，且没有两个相同点，
// 现在要用三个相同的正方形，可以重叠且平行于坐标轴的覆盖所有这些点，
// 问正方形最小的边长。
//
// 题解：
// 其实这题很简单...
// 首先二分；其次通过x, y坐标的最大最小值可以框出一个矩形，然后枚举正方形
// 在四个角的位置，然后取掉覆盖到的点，对于剩下的点继续类似的递归处理。
// 
// 为什么这样是对的呢，对于小于4个正方形可以这么做，这是有原因的。
// 因为假设某次放的不在四个角落，那么也肯定在四个边上，对于框出来的矩形
// 至少有四条边，所以至少需要四个正方形才能覆盖，而题目要求用三个，所以
// 肯定每次正方形会落到四个角之一（贴两条矩形的边）。
//
// run: $exec < input
#include <iostream>
#include <algorithm>
#include <vector>

struct point
{
	point() {}
	point(long long x, long long y) : x(x), y(y) {}
	long long x, y;
};

long long const inf = (1ll) << 40;
int const maxn = 20007;
point da[maxn];
int vis[maxn];
int n;

bool inrange(point const& a, point const& b, long long len)
{
	return (a.x <= b.x && b.x <= a.x + len) && (a.y <= b.y && b.y <= a.y + len);
}

bool judge(int tot, long long len)
{
	if (tot == 3) std::fill(vis, vis + n, 0);
	long long minx = inf, miny = inf;
	long long maxx = -inf, maxy = -inf;
	for (int i = 0; i < n; i++) {
		if (vis[i]) continue;
		minx = std::min(minx, da[i].x);
		miny = std::min(miny, da[i].y);
		maxx = std::max(maxx, da[i].x);
		maxy = std::max(maxy, da[i].y);
	}
	if (minx >= inf) return true;
	if (tot == 1) return (maxx - minx <= len) && (maxy - miny <= len);

	std::vector<point> v;
	v.push_back(point(minx, miny));
	v.push_back(point(minx, maxy - len));
	v.push_back(point(maxx - len, miny));
	v.push_back(point(maxx - len, maxy - len));
	for (int i = 0; i < 4; i++) {
		for (int j = 0; j < n; j++) {
			if (vis[j]) continue;
			if (inrange(v[i], da[j], len)) vis[j] = tot;
		}
		if (judge(tot - 1, len)) return true;
		for (int j = 0; j < n; j++)
			if (vis[j] == tot) vis[j] = 0;
	}
	return false;
}

int main()
{
	std::ios::sync_with_stdio(false);
	std::cin >> n;
	for (int i = 0; i < n; i++) std::cin >> da[i].x >> da[i].y;
	long long l = 1, r = inf;
	while (l + 1 < r) {
		long long mid = (l + r) / 2;
		if (judge(3, mid)) r = mid;
		else l = mid;
	}
	if (judge(3, l)) r = l;
	std::cout << r << '\n';
}

